#pragma once

#include<iostream>
#include<ctime>
#include<vector>
#include<memory>
#include <mutex>
#include <thread>
#include<fcntl.h>
#include <cassert>
#include <cstring>
#include<unistd.h>
#include<signal.h>
#include<sys/epoll.h>
#include <functional>
#include <sys/types.h>
#include <arpa/inet.h>
#include <sys/socket.h>
#include<unordered_map>
#include<sys/eventfd.h>
#include <sys/timerfd.h>
#include<condition_variable>

// 日志
#define INF 0
#define DBG 1
#define ERR 2
#define LOG_LEVEL ERR

#define LOG(level, format, ...) do{\
            if(level < LOG_LEVEL)  break;\
            time_t t = time(nullptr);\
            struct tm* stm = localtime(&t);\
            char tem[32] = {0};\
            strftime(tem, 31, "%H:%M:%S", stm);\
            fprintf(stdout, "[%p %s:%s:%d]" format "\n", pthread_self(), tem, __FILE__, __LINE__, ##__VA_ARGS__);\
        }while(0)

#define INF_LOG(format, ...) LOG(INF, format, ##__VA_ARGS__)
#define DBG_LOG(format, ...) LOG(DBG, format, ##__VA_ARGS__)
#define ERR_LOG(format, ...) LOG(ERR, format, ##__VA_ARGS__)

// _buffer的默认大小
#define BUFFER_DEFAULT_SIZE 1024
class Buffer
{
private:
    std::vector<char> _buffer;
    uint64_t _reader_idx;
    uint64_t _writer_idx;
public:
    Buffer()
        :_reader_idx(0), _writer_idx(0), _buffer(BUFFER_DEFAULT_SIZE)
        {}
    
    char* Begin()
    {
        return &(*_buffer.begin());
    }
    // 获取当前写入起始地址
    char* WritePosition()
    {
        return Begin() + _writer_idx;
    }
    // 获取当前读取起始地址
    char* ReadPosition()
    {
        return Begin() + _reader_idx;
    }
    // 获取缓冲区末尾空闲空间大小 -- 写偏移之后的空闲空间
    uint64_t TailIdleSize()
    {
        return _buffer.size() - _writer_idx;
    }
    // 获取缓冲区起始空闲空间大小 -- 读偏移之前的空闲空间
    uint64_t HeadIdleSize()
    {
        return _reader_idx;
    }
    // 获取可读取数据大小
    uint64_t ReadAbleSize()
    {
        return _writer_idx - _reader_idx;
    }
    // 将读偏移向后移动
    void MoveReadOffset(uint64_t len)
    {
        if(len == 0)  return;
        // 向后移动的大小, 必须小于可读数据的大小
        assert(len <= ReadAbleSize());
        _reader_idx += len;
    }
    // 将写偏移向后移动
    void MoveWriteOffset(uint64_t len)
    {
        // 向后移动的大小, 必须小于缓冲区末尾空闲空间大小
        assert(len <= TailIdleSize());
        _writer_idx += len;
    }
    // 确保可写空间足够
    void EnableWriteSpace(uint64_t len)
    {
        // 如果缓冲区末尾空闲空间足够, 直接返回
        if(len <= TailIdleSize())  return;

        // 如果末尾空间不够, 则判断加上起始空闲空间是否足够
        // 1.足够的情况, 就将数据移动到起始位置
        if(len <= TailIdleSize() + HeadIdleSize())
        {
            // 保存当前数据大小
            uint64_t rsz = ReadAbleSize();
            // 把可读数据拷贝到起始位置
            std::copy(ReadPosition(), ReadPosition() + rsz, Begin());
            // 改变读写偏移
            _reader_idx = 0;
            _writer_idx = rsz;
        }
        // 2.总体空间不够, 则需要扩容--> 不移动数据, 直接给写偏移之后扩容足够空间即可
        else
        {
            _buffer.resize(_writer_idx + len);
        }
    }

    // 写入数据
    void Write(const void* data, uint64_t len)
    {
        if(len == 0)  return;
        // 1. 保证可写空间足够
        EnableWriteSpace(len);
        // 2.将数据拷贝进去
        const char* d = (const char*)data;
        std::copy(d, d + len, WritePosition());
    }

    void WriteString(const std::string& data)
    {
        return Write(data.c_str(), data.size());
    }

    void WriteBuffer(Buffer& data)
    {
        return Write(data.ReadPosition(), data.ReadAbleSize());
    }

    void WriteAndPush(const void* data, uint64_t len)
    {
        Write(data, len);
        MoveWriteOffset(len);
    }

    void WriteStringAndPush(const std::string& data)
    {
        WriteString(data);
        MoveWriteOffset(data.size());
    }

    void WriteBufferAndPush(Buffer& data)
    {
        WriteBuffer(data);
        MoveWriteOffset(data.ReadAbleSize());
    }

    // 读取数据
    void Read(void* buf, uint64_t len)
    {
        // 读取数据的长度要小于可读数据的长度
        assert(len <= ReadAbleSize());
        std::copy(ReadPosition(), ReadPosition() + len, (char*)buf);
    }

    std::string ReadAsString(uint64_t len)
    {
        // 读取数据的长度要小于可读数据的长度
        assert(len <= ReadAbleSize());

        std::string str;
        str.resize(len);
        Read(&str[0], len);

        return str;
    }

    void ReadAndPop(void* buf, uint64_t len)
    {
        Read(buf, len);
        MoveReadOffset(len);
    }

    std::string ReadAsStringAndPop(uint64_t len)
    {
        assert(len <= ReadAbleSize());
        std::string str = ReadAsString(len);
        MoveReadOffset(len);

        return str;
    }

    char* FindCRLF()
    {
        char* res = (char*)memchr(ReadPosition(), '\n', ReadAbleSize());
        return res;
    }

    // 通常情况下是获取一行数据
    std::string GetLine()
    {
        char* pos = FindCRLF();
        if(pos == nullptr)
        {
            return "";
        }
        // +1是为了把换行字符也取出来, 以免下一次提取出一行数据就是一个换行
        return ReadAsString(pos - ReadPosition() + 1 );
    }

    std::string GetLineAndPop()
    {
        std::string str = GetLine();
        MoveReadOffset(str.size());
        return str;
    }

    // 清空缓冲区 -- 只需要将偏移量归0即可
    void Clear()
    {
        _writer_idx = 0;;
        _reader_idx = 0;
    }
};

#define MAX_LISTEN  1024
class Socket
{
private:
    int _sockfd;

public:
    Socket() : _sockfd(-1) {}
    Socket(int fd) : _sockfd(fd) {}
    ~Socket() {}

    int Fd() { return _sockfd; }

    // 创建套接字
    bool Create()
    {
        _sockfd = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
        if(_sockfd < 0)
        {
            ERR_LOG("create socket failed!");
            return false;
        }
        return true;
    }

    // 绑定地址信息
    bool Bind(const std::string& ip, uint16_t port)
    {
        struct sockaddr_in addr;
        addr.sin_family = AF_INET;
        addr.sin_port = htons(port);
        addr.sin_addr.s_addr = inet_addr(ip.c_str());
        socklen_t len = sizeof(struct sockaddr_in);

        int res = bind(_sockfd, (struct sockaddr*)&addr, len);
        if(res < 0)
        {
            ERR_LOG("bind address failed!");
            return false;
        }
        return true;
    }

    // 开始监听
    bool Listen(int backlog = MAX_LISTEN)
    {
        int res = listen(_sockfd, backlog);
        if(res < 0)
        {
            ERR_LOG("socket listen failed!");
            return false;
        }
        return true;
    }

    // 向服务器发起连接
    bool Connect(const std::string& ip, uint16_t port)
    {
        struct sockaddr_in addr;
        addr.sin_family = AF_INET;
        addr.sin_port = htons(port);
        addr.sin_addr.s_addr = inet_addr(ip.c_str());
        socklen_t len = sizeof(struct sockaddr_in);

        int res = connect(_sockfd, (struct sockaddr*)&addr, len);
        if(res < 0)
        {
            ERR_LOG("connect server failed!");
            return false;
        }
        return true;
    }

    // 获取新连接
    int Accept()
    {
        int newfd = accept(_sockfd, nullptr, nullptr);
        if(newfd < 0)
        {
            ERR_LOG("socket accept failed!");
            return -1;
        }
        return newfd;
    }

    // 接收数据
    ssize_t Recv(void* buf, size_t len, int flag = 0)
    {
        ssize_t res = recv(_sockfd, buf, len, flag);
        if(res <= 0)
        {
            // EAGAIN -- 表示当前socket的接收缓冲区中没有数据了, 在非阻塞的情况下才会有这个问题
            // EINTR  -- 表示当前socket的阻塞等待, 被信号打断了
            if(errno == EAGAIN || errno == EINTR)
            {
                // 表示这次接收没有收到数据
                return 0;
            }
            ERR_LOG("socket recv failed!");
            return -1;
        }

        // 返回实际接收到的长度
        return res;
    }

    ssize_t NonBlockRecv(void* buf, size_t len)
    {
        // MSG_DONTWAIT -- 表示当前接收为非阻塞
        return Recv(buf, len, MSG_DONTWAIT);
    }

    // 发送数据
    ssize_t Send(const void* buf, size_t len, int flag = 0)
    {
        ssize_t res = send(_sockfd, buf, len, flag);
        if(res < 0)
        {
            if(errno == EAGAIN || errno == EINTR)
            {
                return 0;
            }
            ERR_LOG("socket send failed!");
            return -1;
        }
        // 实际发送的数据长度
        return res;
    }

    ssize_t NonBlockSend(void* buf, size_t len)
    {
        if(len == 0)  return 0;
        // MSG_DONTWAIT -- 表示当前接收为非阻塞
        return Send(buf, len, MSG_DONTWAIT);
    }

    // 关闭套接字
    void Close()
    {
        if(_sockfd != -1)
        {
            close(_sockfd);
            _sockfd = -1;
        }
    }

    // 创建一个服务器连接
    bool CreateServer(uint16_t port, const std::string& ip = "0.0.0.0", bool block_flag = false)
    {
        // 1.创建套接字
        if(Create() == false)  return false;
        // 2.设置为非阻塞
        if(block_flag) NonBlock();
        // 3.绑定地址
        if(Bind(ip, port) == false)  return false;
        // 4.开始监听
        if(Listen() == false)  return false;
        // 5.启动地址重用
        ReuseAddress();

        return true;
    }

    // 创建一个客户端连接
    bool CreateClient(uint16_t port, const std::string& ip)
    {
        // 1.创建套接字
        if(Create() == false)  return false;
        // 2.指向连接服务器
        if(Connect(ip, port) == false)  return false;

        return true;
    }

    // 设置套接字选项 -- 开启地址端口重用
    void ReuseAddress()
    {
        int val = 1;
        setsockopt(_sockfd, SOL_SOCKET, SO_REUSEADDR, (void*)&val, sizeof(int));
        val = 1;
        setsockopt(_sockfd, SOL_SOCKET, SO_REUSEPORT, (void*)&val, sizeof(int));
    }

    // 设置套接字阻塞属性 -- 设置为非阻塞
    void NonBlock()
    {
        int flag = fcntl(_sockfd, F_GETFL, 0);
        fcntl(_sockfd, F_SETFL, flag | O_NONBLOCK);
    }

};

class EventLoop;
class Channel
{
private:
    EventLoop* _loop;
    int _fd;
    uint32_t _events;  // 当前已经监控的事件
    uint32_t _revents; // 当前连接触发的事件
    using EventCallback = std::function<void()>;
    EventCallback _read_callback;   // 可读事件被触发的回调函数
    EventCallback _write_callback;   // 可写事件被触发的回调函数
    EventCallback _error_callback;   // 错误事件被触发的回调函数
    EventCallback _close_callback;   // 连接断开事件被触发的回调函数
    EventCallback _event_callback;   // 任意事件被触发的回调函数

public:
    Channel(EventLoop* loop, int fd) :_fd(fd), _events(0), _revents(0), _loop(loop) {}
    int Fd() { return _fd; };

    //  获取想要监控的事件
    uint32_t Events() { return _events; }

    // 设置实际就绪的事件
    void SetREvents(uint32_t events) { _revents = events; }

    void SetReadCallback(const EventCallback& cb) { _read_callback = cb; }

    void SetWriteCallback(const EventCallback& cb) { _write_callback = cb; }

    void SetErrorCallback(const EventCallback& cb) { _error_callback = cb; }

    void SetCloseCallback(const EventCallback& cb) { _close_callback = cb; }

    void SetEventCallback(const EventCallback& cb) { _event_callback = cb; }

    // 当前是否监控了可读
    bool ReadAble() { return (_events & EPOLLIN); }

    // 当前是否监控可写
    bool WriteAble() { return (_events & EPOLLOUT); }

    // 启动读事件监控
    void EnableRead()
    {
        // 后边会添加到EventLoop的事件监控中
        _events |= EPOLLIN;
        Update();
    }

    // 启动写事件监控
    void EnableWrite()
    {
        // 后边会添加到EventLoop的事件监控中
        _events |= EPOLLOUT;
        Update();
    }

    // 关闭读事件监控
    void DisableRead()
    {
        // 后边会添加到EventLoop的事件监控中
        _events &= ~EPOLLIN;
        Update();
    }

    // 关闭写事件监控
    void DisableWrite()
    {
        // 后边会添加到EventLoop的事件监控中
        _events &= ~EPOLLOUT;
        Update();
    }

    // 关闭所有事件监控
    void DisableAll()
    {
        _events = 0;
    }

    // 移除监控
    void Remove();
    void Update();
    
    // 事件处理, 一旦连接触发了事件, 就调用这个函数
    // EventLoop只会调用这个接口, 而自己触发了什么事情,如何处理, 自己来决定
    void HeadleEvent()
    {
        if((_revents & EPOLLIN) || (_revents & EPOLLRDHUP) || (_revents & EPOLLPRI))
        {
            // 不管任何事件, 都要调用的回调函数
            // 放到事件处理后, 刷新活跃度
            if(_read_callback)  _read_callback();

        }
        // 有可能会释放连接的操作事件, 一次只处理一个
        if(_revents & EPOLLOUT)
        {
            // 放到事件处理后, 刷新活跃度
            if(_write_callback)  _write_callback();

        }
        else if(_revents & EPOLLERR)
        {
            // 一旦出错, 就会释放连接, 因此要放到前边调用任意回调
            if(_error_callback)  _error_callback();
        }
        else if(_revents & EPOLLHUP)
        {
            // 一旦出错, 就会释放连接, 因此要放到前边调用任意回调
            if(_close_callback)  _close_callback();
        }

        if(_event_callback)  _event_callback();

    }
};

#define MAX_EPOLLEVENTS 1024
class Poller
{
private:
    int _epfd;
    struct epoll_event _evs[MAX_EPOLLEVENTS];
    std::unordered_map<int, Channel*> _channels;

private:
    // 对epoll的直接操作
    void Update(Channel* channel, int op)
    {
        int fd = channel->Fd();
        struct epoll_event ev;
        ev.data.fd = fd;
        ev.events = channel->Events();
        int res = epoll_ctl(_epfd, op, fd, &ev);
        if(res < 0)
        {
            ERR_LOG("epollctl failed!");
        }
        return;
    }

    // 判断一个Channel是否已经添加了事件监控
    bool HasChannel(Channel* channel)
    {
        auto iter = _channels.find(channel->Fd());
        if(iter == _channels.end())
        {
            return false;
        }
        return true;
    }

public:
    Poller()
    {
        _epfd = epoll_create(MAX_EPOLLEVENTS);
        if(_epfd < 0)
        {
            ERR_LOG("eopll create failed!");
            abort(); // 退出程序
        }
    }

    // 添加或修改监控事件
    void UpdateEvent(Channel* channel)
    {
        bool res = HasChannel(channel);
        if(res == false)
        {
            // 不存在就添加
            _channels.insert(std::make_pair(channel->Fd(), channel));
            return Update(channel, EPOLL_CTL_ADD);
        }
        // 存在就更新
        return Update(channel, EPOLL_CTL_MOD);
    }

    // 移除监控
    void RemoveEvent(Channel* channel)
    {
        auto iter = _channels.find(channel->Fd());
        if(iter != _channels.end())
        {
            _channels.erase(iter);
        }
        Update(channel, EPOLL_CTL_DEL);
    }

    // 开始监控, 返回活跃连接
    void  Poll(std::vector<Channel*>* active)
    {
        // 阻塞式
        int nfds = epoll_wait(_epfd, _evs, MAX_EPOLLEVENTS, -1);
        if(nfds < 0)
        {
            if(errno == EINTR)
            {
                return;
            }
            ERR_LOG("epoll wait error: %s", strerror(errno));
            abort(); // 退出程序
        }

        for(int i = 0; i < nfds; i++)
        {
            auto iter = _channels.find(_evs[i].data.fd);
            assert(iter != _channels.end());
            // 设置实际就绪的事件
            iter->second->SetREvents(_evs[i].events);
            active->push_back(iter->second);
        }

        return;
    }

};

using TaskFunc = std::function<void()>;
using ReleaseFunc = std::function<void()>;
class TimeTask
{
private:
    uint64_t _id;       // 定时器任务对象ID
    uint32_t _timeout;  // 定时器任务的超时时间
    TaskFunc _task_cb;  // 定时器对象要执行的定时任务
    ReleaseFunc _release; // 用于删除TimeWheel中保存的定时器对象信息
    bool _canceled;      // false - 表示没有被取消, true - 表示被取消了.

public:
    TimeTask(uint64_t id, uint32_t delay, const TaskFunc& cb)
        :_id(id), _timeout(delay), _task_cb(cb), _canceled(false)
        {}
    // 取消一个定时任务
    void Cancel()
    {
        _canceled = true;
    }

    // 析构 -- 定时任务被执行
    ~TimeTask() 
    {
        // 任务没有被取消, 才会执行
        if(_canceled == false)  _task_cb();
        _release();
    }
    void SetRelease(const ReleaseFunc& cb)
    {
        _release = cb;
    }
    uint32_t DelayTime()
    {
        return _timeout;
    }

};

class TimerWheel
{
private:
    using WeakTask = std::weak_ptr<TimeTask>;
    using PtrTask = std::shared_ptr<TimeTask>;
    int _tick;  // 当前的秒针, 走到哪里释放哪里. 释放哪里, 就相当于执行哪里的任务
    int _capacity; // 表盘最大数量--其实就是最大延迟时间
    std::vector<std::vector<PtrTask>> _wheel;
    std::unordered_map<uint64_t, WeakTask> _timers;

    // 定时器描述符 -- 可读事件的回调就是去取计数器, 执行定时任务
    int _timerfd = 0; 
    EventLoop* _loop;
    std::unique_ptr<Channel> _timer_channel;

private:
    void RemoveTimer(uint64_t id)
    {
        auto it = _timers.find(id);
        if(it != _timers.end())
        {
            _timers.erase(it);
        }
    }

    static int CreateTimerfd()
    {
        int timerfd = timerfd_create(CLOCK_MONOTONIC, 0);
        if(timerfd < 0)
        {
            ERR_LOG("timefd create failed!");
            abort(); // 异常退出
        }
        struct itimerspec itime;
        itime.it_value.tv_sec = 1;
        itime.it_value.tv_nsec = 0; // 第一次超时时间为1s后
        itime.it_interval.tv_sec = 1;
        itime.it_interval.tv_nsec = 0; // 第一次超时后, 每次超时时间间隔
        
        timerfd_settime(timerfd, 0, &itime, nullptr);

        return timerfd;
    }

    int ReadTimerfd()
    {
        uint64_t timers;
        // 有可能因为其他描述符的事件处理花费时间较长, 然后在处理定时器描述符事件的时候, 已经超时了很多次
        // read读取的数据timers是上一次read之后的超时的次数
        // ==> 可以返回timers, 然后在Ontime模块中, 进行timers次RunTimerTask
        int res = read(_timerfd, &timers, 8);
        if(res < 0)
        {
            ERR_LOG("read timerfd failed!");
            abort();
        }
        return timers;
    }

    // 每秒钟执行一次, 相当于秒针向后走了一步
    void RunTimerTask()
    {
        _tick = (_tick + 1) % _capacity;
        // 清空指定位置的数组, 就会把数组中保存的所有管理定时器对象的shar_ptr释放掉
        _wheel[_tick].clear();
    }

    void OnTime()
    {
        // 清空定时器
        int n = ReadTimerfd();
        // 执行定时任务 -- 根据实际的超时次数, 来执行定时任务
        for(int i = 0; i < n; i++)
        {
            RunTimerTask();
        }
    }

    void TimerAddInLoop(uint64_t id, uint32_t delay, const TaskFunc& cb)
    {
        PtrTask pt(new TimeTask(id, delay, cb));
        pt->SetRelease(std::bind(&TimerWheel::RemoveTimer, this, id));
        int pos = (_tick + delay) % _capacity;
        _wheel[pos].push_back(pt);
        _timers[id] = WeakTask(pt);
    }

    // 刷新/延迟定时任务
    void TimerRefreshInLoop(u_int64_t id)
    {
        // 通过保存的定时器对象中的weak_ptr构造出一个shard_ptr出来, 添加到轮子中
        auto it = _timers.find(id);
        if(it == _timers.end())
        {
            return; // 没找到定时任务, 没法刷新, 没法延迟
        }
        PtrTask pt = it->second.lock(); // lock获取weak_ptr管理的对象对应的shard_ptr
        int delay = pt->DelayTime();
        int pos = (delay + _tick) % _capacity;
        _wheel[pos].push_back(pt);
    }

    // 取消一个定时任务
    void TimerCancelInLoop(uint64_t id)
    {
        auto it = _timers.find(id);
        if(it == _timers.end())
        {
            return;
        }

        PtrTask pt = it->second.lock();
        if(pt)  pt->Cancel();
    }

public:
    TimerWheel(EventLoop* loop)
        :_tick(0), _capacity(60), _wheel(_capacity), _loop(loop)
        ,_timerfd(CreateTimerfd()), _timer_channel(new Channel(_loop, _timerfd))
        {
            _timer_channel->SetReadCallback(std::bind(&TimerWheel::OnTime, this));
            _timer_channel->EnableRead();  // 启动读事件监控
        }

    // 因为定时器信息的操作有可能在多线程中进行 需要考虑线程安全问题
    // 不想加锁 && 想要线程安全 --> 把定时器的所有操作, 都放在一个线程中进行
    void TimerAdd(uint64_t id, uint32_t delay, const TaskFunc& cb);
    
    void TimerRefresh(u_int64_t id);

    void TimerCancel(uint64_t id);

    // 是否存在一个定时任务
    // 存在线程安全问题 -- 所以不能被外界使用, 只能在模块内,在对应的EventLoop线程中执行
    bool HasTimer(uint64_t id)
    {
        auto iter = _timers.find(id);
        if(iter == _timers.end())
        {
            // 没有找到定时任务, 没法刷新, 没法执行
            return false;
        }
        return true;
    }
};

class EventLoop
{
private:
    using Functor = std::function<void()>;
    std::thread::id _thread_id;  // 线程ID
    int _event_fd;  // eventfd唤醒IO事件监控有可能导致的阻塞
    std::unique_ptr<Channel> _event_channel;
    Poller _poller; // 进行所有描述符的事件监控
    std::vector<Functor> _tasks;  // 任务池
    std::mutex _mutex;  // 实现任务池操作的线程安全
    TimerWheel _timer_wheel;  // 定时器模块

public:
    // 执行任务池中的所有任务
    void RunAllTask()
    {
        std::vector<Functor> functor;
        {
            std::unique_lock<std::mutex> _lock(_mutex);
            _tasks.swap(functor);
        }

        for(auto& e : functor)
        {
            e();
        }

        return;
    }

public:
    static int CreateEventFd()
    {
        int efd = eventfd(0, EFD_CLOEXEC | EFD_NONBLOCK);
        if(efd < 0)
        {
            ERR_LOG("create eventfd failed!");
            abort(); // 程序异常退出
        }
        return efd;
    }
    void ReadEventFd()
    {
        uint64_t res = 0;
        int n = read(_event_fd, &res, sizeof(res));
        if(n < 0)
        {
            // EAGAIN -- 表示无数据可读, EEINTR -- 表示被信号打断
            if(errno == EAGAIN || errno == EINTR)
            {
                return;
            }
            ERR_LOG("read eventfd failed!");
            abort(); // 异常退出
        }
        return;
    }

    void WeakUpEventFd()
    {
        uint64_t val = 1;
        int res = write(_event_fd, &val, sizeof(val));
        if(res < 0)
        {
            if(errno == EAGAIN || errno == EINTR)
            {
                return ;
            }
            ERR_LOG("weakup eventfd failed!");
            abort(); // 异常退出
        }
        return;
    }

    EventLoop()
        :_thread_id(std::this_thread::get_id())
        ,_event_fd(CreateEventFd())
        ,_event_channel(new Channel(this, _event_fd))
        ,_timer_wheel(this)
    {
        // 给eventfd添加可读事件的回调函数, 读取eventfd事件通知次数
        _event_channel->SetReadCallback(std::bind(&EventLoop::ReadEventFd, this));

        // 启动eventfd的读事件监控
        _event_channel->EnableRead();
    }

    // 三步走: 事件监控->就绪事件处理->执行任务
    void Start()
    {
        while(1)
        {
            // 1. 事件监控
            std::vector<Channel*> actives;
            _poller.Poll(&actives);
            // 2.就绪事件处理
            for(auto& e : actives)
            {
                e->HeadleEvent();
            }
            // 3.执行任务
            RunAllTask();
        }
    }
    
    // 判断将要执行的任务是否处于当前线程中, 如果是则执行, 不是则压入任务池中
    void RunInLoop(const Functor& cb)
    {
        if(IsInLoop())
        {
            return cb();
        }
        return QueueInLoop(cb);
    }

    void AsertInLoop()
    {
        assert (_thread_id == std::this_thread::get_id());
    }

    // 将操作压入任务池
    void QueueInLoop(const Functor& cb)
    {
        {
            std::unique_lock<std::mutex> _lock(_mutex);
            _tasks.push_back(cb);
        }
        // 唤醒有可能因为没有事件就绪, 而导致的epoll阻塞
        // 其实就是给eventfd写入一个数据, eventfd就会触发可读事件
        WeakUpEventFd();
    }

    // 用于判断当前线程是否是EventLoop对应的线程
    bool IsInLoop()
    {
        return (_thread_id == std::this_thread::get_id());
    }

    // 添加/修改描述符的事件监控
    void UpdateEvent(Channel* channel)
    {
        return _poller.UpdateEvent(channel);
    }

    // 移除描述符的监控
    void RemoveEvent(Channel* channel)
    {
        return _poller.RemoveEvent(channel);
    }

    void TimerAdd(uint64_t id, uint32_t delay, const TaskFunc& cb)
    {
        return _timer_wheel.TimerAdd(id, delay, cb);
    }
    
    void TimerRefresh(u_int64_t id)
    {
        return _timer_wheel.TimerRefresh(id);
    }

    void TimerCancel(uint64_t id)
    {
        return _timer_wheel.TimerCancel(id);
    }

    bool HasTimer(uint64_t id)
    {
        return _timer_wheel.HasTimer(id);
    }

};

class LoopThread
{
private:
    // 加锁和条件变量是为了实现_loop获取的同步互斥关系
    // --> 避免线程创建了, 但是_loop还没有实例化之前去获取_loop
    std::mutex _mutex; // 互斥锁
    std::condition_variable _cond; // 条件变量

    EventLoop* _loop;
    std::thread _thread;

private:
    // 实例化EventLoop对象, 唤醒_cond上有可能阻塞的线程, 并且开始运行EventLoop模块功能
    void ThreadEntry()
    {
        EventLoop loop;
        {
            std::unique_lock<std::mutex> lock(_mutex); // 加锁
            _loop = &loop;
            // 唤醒_cond上有可能阻塞的线程
            _cond.notify_all();
        }
        loop.Start();
    }

public:
    // 创建线程, 设定线程入口函数
    LoopThread()
        :_loop(nullptr), _thread(std::thread(&LoopThread::ThreadEntry, this))
    {}

    // 返回当前线程关联的EventLoop对象指针
    EventLoop* GetLoop()
    {
        EventLoop* loop = nullptr;
        {
            std::unique_lock<std::mutex> lock(_mutex); // 加锁
            // _loop为nullptr, 就一直阻塞
            _cond.wait(lock, [&](){return _loop != nullptr;}); 
            loop = _loop;
        }

        return loop;
    }
};

class LooPThreadPool
{
private:
    int _thread_count; // 从属线程的数量
    int _next_loop_idx; // 当前处理的从属线程的下标 -- 采用RR轮转思想
    EventLoop* _baseloop; // 主Eventloop, 运行在主线程 -- 从属线程数量为0, 则所有操作都在baseloop中运行
    std::vector<LoopThread*> _threads; // 保存所有的从属线程
    std::vector<EventLoop*> _loops; // 从属线程大于0, 则从_loops中进行线程EventLoop分配
public:
    LooPThreadPool(EventLoop* base_loop)
        :_thread_count(0), _next_loop_idx(0), _baseloop(base_loop)
    {}

    // 设置线程数量
    void SetThreadCount(int count)
    {
        _thread_count = count;
    }

    // 创建所有的从属线程
    void Create()
    {
        if(_thread_count > 0)
        {
            _threads.resize(_thread_count);
            _loops.resize(_thread_count);
            for(int i = 0; i < _thread_count; i++)
            {
                _threads[i] = new LoopThread();
                _loops[i] = _threads[i]->GetLoop();
            }
        }

        return;
    }

    EventLoop*  NextLoop()
    {
        if(_thread_count == 0)
        {
            return _baseloop;
        }

        _next_loop_idx = (_next_loop_idx + 1) % _thread_count;
        return _loops[_next_loop_idx];
    }

};

class Any
{
    private:
        class holder
        {
            public:
                virtual ~holder() {}
                virtual const std::type_info& type() = 0;
                virtual holder *clone() = 0;
        };

        template<class T>
        class placeholder : public holder
        {
            public:
                placeholder(const T& val)
                    :_val(val)
                    {}
                
                // 获取子类对象保存的数据类型
                virtual const std::type_info& type()
                {
                    return typeid(T);
                }

                // 针对当前的对象, 克隆出一个新的子类对象
                virtual holder* clone()
                {
                    return new placeholder<T>(_val);
                }
            public:
                T _val;
        };
    private:
        holder* _content;

    public:
        // 构造
        Any() :_content(nullptr) {}
        template<class T>
        Any(const T& val)
            :_content(new placeholder<T>(val))
            {}
        Any(const Any& other)
            :_content(other._content ? other._content->clone() : nullptr)
            {}

        Any& swap(Any& other)
        {
            std::swap(_content, other._content);
            return *this;
        }

        // 赋值运算符的重载
        template<class T>
        Any& operator=(const T& val)
        {
            Any(val).swap(*this);
            return *this;
        }
        Any& operator=(const Any& other)
        {
            Any(other).swap(*this);
            return *this;
        }

        // 返回子类对象保存的数据的指针
        template<class T>
        T* get()
        {
            // 想要获取的数据类型, 必须要和保存的数据类型一致
            assert(typeid(T) == _content->type());
            return &((placeholder<T>*)_content)->_val;
        }

        ~Any()
        {
            delete _content;
        }
};

class Connection;
// 连接的状态类型
typedef enum
{
    DISCONNECTED, // 连接关闭状态
    CONNECTING, // 连接建立成功-待处理状态
    CONNECTED, // 连接建立完成 -- 各种设置已完成, 可以通信的状态
    DISCONNECTING // 待关闭状态
}ConnectStatus;

using PtrConnection = std::shared_ptr<Connection>;
class Connection : public std::enable_shared_from_this<Connection>
{
private:
    EventLoop* _loop; // 连接所关联的loop, 即所关联的一个线程
    uint64_t _connectid; // 连接的唯一id, 便于连接的管理和查找
    // uint64 _timerid; // 定时器id, 必须是唯一的, 为了简化操作, 这里使用connectionid作为定时器id
    int _sockfd; // 连接关联的文件描述符
    bool _enable_inactive_release; // 连接是否启动非活跃销毁的判断标志, 默认是不启动
    Socket _socket; // 套接字操作管理
    Channel _channel; // 连接的事件管理
    Buffer _in_buffer; // 输入缓冲区 -- 存放从socket读取到的数据
    Buffer _out_buffer; // 输出缓冲区 -- 存放要发送给对端的数据
    Any _context; // 请求的接收处理上下文
    ConnectStatus _status; // 连接的状态

    // 这四个回调函数, 是让服务器模块来设置的 -- 其实服务器模块的处理回调也是组件使用者来设置的
    // --> 这四个回调都是组件使用者设置的
    using ConectedCallback = std::function<void(const PtrConnection&)>;
    using MessageCallback = std::function<void(const PtrConnection&, Buffer*)>;
    using CloseCallback = std::function<void(const PtrConnection&)>;
    using AnyEventCallback = std::function<void(const PtrConnection&)>;
    ConectedCallback _connected_callback;
    MessageCallback _message_callback;
    CloseCallback _close_callback;
    AnyEventCallback _anyevent_callback;

    // 组件内的连接关闭回调 -- 组件内设置的, 因为服务器组件会把所有的连接管理起来,
    // 一旦某个连接要关闭, 就应该从管理的地方移除自己的信息
    CloseCallback _server_closecallback;

private:
    // 五个channel的事件回调函数
    // 描述符触发可读事件后调用的函数 -- 接收socket数据放到接收缓冲区中, 然后调用_message_callback
    void HandleRead()
    {
        // 1.接收socket的数据, 并放到缓冲区
        char buf[65536];
        ssize_t res = _socket.NonBlockRecv(buf, 65535);
        if(res < 0)
        {
            // 出错了, 不能直接关闭连接
            return ShutdownInLoop();
        }
        // 不用担心这里res = 0的情况 -- 0表示没有读取到数据, -1表示连接断开
        // 将读取到的数据放到缓冲区
        _in_buffer.WriteAndPush(buf, res);
        // 2.调用message_callback进行业务处理
        if(_in_buffer.ReadAbleSize() > 0)
        {
            // shared_from_this -- 从当前对象自身获取的shared_ptr管理对象
            return _message_callback(shared_from_this(), &_in_buffer);
        }
    }

    // 描述符触发可写事件后调用的函数 -- 将发送缓冲区中的数据进行发送
    void HandleWrite()
    {
        // out_buffer中保存的数据就是要发送的数据
        ssize_t res = _socket.NonBlockSend(_out_buffer.ReadPosition(), _out_buffer.ReadAbleSize());
        if(res < 0)
        {
            // 发送错误就该关闭连接
            if(_in_buffer.ReadAbleSize() > 0)
            {
                _message_callback(shared_from_this(), &_in_buffer);
            }
            // 实际的关闭释放操作
            return Release();
        }

        // 将读偏移向后移动
        _out_buffer.MoveReadOffset(res);
        if(_out_buffer.ReadAbleSize() == 0)
        {
            // 没有数据待发送了, 关闭写事件监控
            _channel.DisableWrite();
            //  如果当前也是连接关闭状态 --> 则有数据, 发送完数据后释放连接, 没有数据, 直接释放连接
            if(_status == DISCONNECTING)
            {
                return Release();
            }
        }
        return;
    }

    // 描述符触发挂断事件后调用的函数
    void HandleClose()
    {
        // 一旦连接断开了, 套接字就什么干不了了
        // --> 有数据就处理一下, 再关闭连接
        if(_in_buffer.ReadAbleSize() > 0)
        {
            _message_callback(shared_from_this(), &_in_buffer);
        }
        return Release();
    }

    // 描述符触发出错事件后调用的函数
    void HandleError()
    {
        return HandleClose();
    }

    // 描述符触发任意事件后调用的函数
    void HandleEvent()
    {
        // 1.刷新连接的活跃度 -- 就是延迟定时任务
        if(_enable_inactive_release == true)
        {
            _loop->TimerRefresh(_connectid);
        }
        // 2.调用组件使用者的任意事件回调
        if(_anyevent_callback)
        {
            return _anyevent_callback(shared_from_this());
        }
    }

    // 并不是实际的发送接口, 将数据放到发送缓冲区, 启动写事件监控
    void SendInLoop(Buffer& buf)
    {
        // 1.将数据放到发送缓冲区
        if(_status == DISCONNECTED)  return;
        _out_buffer.WriteBufferAndPush(buf);
        // 2.启动写事件监控
        if(_channel.WriteAble() == false)
        {
            _channel.EnableWrite();
        }
    }

    // 连接获取之后, 所处的状态下要进行的各种设置
    // 比如: 给channel设置事件回调, 启动读监控... ...
    void EstablishedInloop()
    {
        // 1.修改连接状态
        assert(_status == CONNECTING);  // 当前状态必须是上层的半连接状态
        _status = CONNECTED; // 当前函数执行完毕,  则连接进入已完成连接状态
        // 2.启动读事件监控
        // 一旦启动了读事件监控就有可能会立即触发读事件, 如果这个时候启动了非活跃连接就销毁
        _channel.EnableRead();
        // 3.调用回调函数
        if(_connected_callback)  _connected_callback(shared_from_this());
    }

    // 实际的释放接口
    void ReleaseInLoop()
    {
        // 1. 修改连接状态 -- DISCONNECTED
        _status =  DISCONNECTED;
        // 2. 移除连接的事件监控
        _channel.Remove();
        // 3.关闭描述符
        _socket.Close();
        // 4.如果当前定时器队列中还有定时任务, 则取消任务
        if(_loop->HasTimer(_connectid)) CancelInactiveReleaseInLoop();
        // 5.调用关闭回调函数, 避免先移除服务器管理的连接信息导致Connection被释放, 再去处理会出错
        if(_close_callback)   _close_callback(shared_from_this());
        // 移除服务器内管理的连接信息
        if(_server_closecallback)  _server_closecallback(shared_from_this());
    }

    // 提供给使用者的关闭接口 -- 需要判断有没有数据待处理, 再决定是否关闭
    void ShutdownInLoop()
    {
        // 设置为半关闭状态
        _status = DISCONNECTING;

        if(_in_buffer.ReadAbleSize() > 0)
        {
            if(_message_callback) _message_callback(shared_from_this(), &_in_buffer);
        }
        // 要么就是写入数据的时候出错关闭,  要么就是没有待发送的数据, 直接关闭
        if(_out_buffer.ReadAbleSize() > 0)
        {
            if(_channel.WriteAble() == false)
            {
                _channel.EnableWrite();
            }
        }
        if(_out_buffer.ReadAbleSize() == 0)
        {
            Release();
        }
    }

    // 启动非活跃销毁, 并定义多长时间无通信就是非活跃, 添加定时任务
    void EnableInactiveReleaseInLoop(int sec)
    {
        // 1.将判断标志_enable_inactive_release置为true
        _enable_inactive_release = true;
        // 2.如果当前定时销毁任务已经存在, 那就刷新一下即可
        if(_loop->HasTimer(_connectid))
        {
            return _loop->TimerRefresh(_connectid);
        }
        //  3.如果不存在定时销毁任务, 那就新增
        _loop->TimerAdd(_connectid, sec, std::bind(&Connection::Release, this));
    }

    // 取消非活跃
    void CancelInactiveReleaseInLoop()
    {
        _enable_inactive_release = false;
        if(_loop->HasTimer(_connectid))
        {
            _loop->TimerCancel(_connectid);
        }
    }

    // 切换协议 -- 就是重置上下文以及阶段性处理函数
    void SwitchProtocolInLoop(const Any& context, const ConectedCallback& connect, const MessageCallback& msg,\
                        const CloseCallback& close, const AnyEventCallback& event)
    {
        _context = context;
        _connected_callback = connect;
        _message_callback =  msg;
        _close_callback = close;
        _anyevent_callback = event;
    }

public:
    Connection(EventLoop* loop, uint64_t connectid, int sockfd)
        :_connectid(connectid),  _sockfd(sockfd), _socket(_sockfd)
        ,_enable_inactive_release(false),  _loop(loop), _status(CONNECTING)
        , _channel(loop, _sockfd)
    {
        _channel.SetReadCallback(std::bind(&Connection::HandleRead, this));
        _channel.SetWriteCallback(std::bind(&Connection::HandleWrite, this));
        _channel.SetEventCallback(std::bind(&Connection::HandleEvent, this));
        _channel.SetCloseCallback(std::bind(&Connection::HandleClose, this));
        _channel.SetErrorCallback(std::bind(&Connection::HandleError, this));
    }

    ~Connection()
    {
        ERR_LOG("release connection > %p", this);
    }

    // 获取所管理的文件描述符
    int Fd()
    {
        return _sockfd;
    }

    // 获取连接id
    int ConnectId()
    {
        return _connectid;
    }

    // 是否处于CONNECTED状态
    bool Connected()
    {
        return _status == CONNECTED;
    }

    // 连接建立成功(CONNECTING)状态时, 设置上下文
    void SetContext(const Any& context)
    {
        _context = context;
    }
    // 获取上下文 -- 返回指针
    Any* GetContext()
    {
        return &_context;
    }

    // 发送数据, 将数据放到发送缓冲区, 启动写事件监控
    void Send(const char* data, size_t len)
    {
        // 外界传入的data, 可能是个临时的空间, 
        // 我们当前的操作知识把发送操作压入了任务池, 有可能并没有立即执行
        // --> 有可能会导致执行的时候, data指向的空间可能已经被释放了
        // ==> 所以我们要用一个缓冲区变量
        Buffer buf;
        buf.WriteAndPush(data, len);
        _loop->RunInLoop(std::bind(&Connection::SendInLoop, this, std::move(buf)));
    }
 
    void SetConectedCallback(const ConectedCallback& cb)
    {
        _connected_callback = cb;
    }

    void SetMessageCallback(const MessageCallback& cb)
    {
        _message_callback = cb;
    }

    void SetCloseCallback(const CloseCallback& cb)
    {
        _close_callback = cb;
    }

    void SetAnyEventCallback(const AnyEventCallback& cb)
    {
        _anyevent_callback = cb;
    }

    void SetServerCloseCallback(const CloseCallback& cb)
    {
        _server_closecallback = cb;
    }

    // 提供给使用者的关闭接口 -- 需要判断有没有数据待处理, 再决定是否关闭
    void Shutdown()
    {
        _loop->RunInLoop(std::bind(&Connection::ShutdownInLoop, this));
    }

    void Release()
    {
        _loop->QueueInLoop(std::bind(&Connection::ReleaseInLoop, this));
    }

    // 启动非活跃销毁, 并定义多长时间无通信就是非活跃, 添加定时任务
    void EnableInactiveRelease(int sec)
    {
        _loop->RunInLoop(std::bind(&Connection::EnableInactiveReleaseInLoop, this, sec));
    }

    // 取消非活跃
    void CancelInactiveRelease()
    {
        _loop->RunInLoop(std::bind(&Connection::CancelInactiveReleaseInLoop, this));
    }

    // 连接获取之后, 所处的状态下要进行的各种设置
    // 比如: 给channel设置事件回调, 启动读监控... ...
    void Established()
    {
        _loop->RunInLoop(std::bind(&Connection::EstablishedInloop, this));
    }

    // 切换协议 -- 就是重置上下文以及阶段性处理函数
    // 存在线程安全问题 --> 必须在EventLoop线程中立即执行
    // 避免新的事件触发后, 处理的时候, 切换任务还没有被执行 -- 会导致数据使用原来的协议处理了
    void SwitchProtocol(const Any& context, const ConectedCallback& connect, const MessageCallback& msg,\
                        const CloseCallback& close, const AnyEventCallback& event)
    {
        _loop->AsertInLoop();
        _loop->RunInLoop(std::bind(&Connection::SwitchProtocolInLoop, this, context, connect, msg, close, event));
    }

};

class Acceptor
{
private:
    // 用于创建监听套接字
    Socket _socket;
    // 用于对监听套接字进行事件监控
    EventLoop* _loop;
    // 用于对监听套接字进行事件管理
    Channel _channel;

    using AcceptCallback = std::function<void(int)>;
    AcceptCallback _accept_callback;

private:
    // 监听套接字的读事件回调处理函数 -- 获取新连接, 调用_accept_callback函数进行新的连接处理
    void HandleRead()
    {
        int newfd = _socket.Accept();
        if(newfd < 0)
        {
            return;
        }
        if(_accept_callback)  _accept_callback(newfd);
    }

    int CreateServer(int port)
    {
        bool res = _socket.CreateServer(port);
        assert(res == true);

        return _socket.Fd();
    }

public:
    // 不能将启动读事件监控 放到构造函数中, 必须要再设置回调函数后, 再去启动
    // 否则就有可能会造成启动监控后, 立即有事件, 处理的时候, 回调函数还没有设置
    // --> 就会导致新连接得不到处理 且 资源泄漏
    Acceptor(EventLoop* loop, int port)
        :_socket(CreateServer(port))
        ,_loop(loop)
        ,_channel(loop, _socket.Fd())
    {
        _channel.SetReadCallback(std::bind(&Acceptor::HandleRead, this));
        // _channel.EnableRead();
    }

    void Listen()
    {
        return _channel.EnableRead();
    }

    void SetAcceptCallback(const AcceptCallback& cb)
    {
        _accept_callback  = cb;
    }
};

class TcpServer
{
private:
    int _port;
    uint64_t _next_index;  // 自动增长的连接id
    int _timerout;           // 非活跃连接的统计时间 -- 多长时间无通信算是非活跃
    bool _enable_inactive_release; // 是否启动了非活跃连接超时销毁的判断标志
    EventLoop _base_loop;    // 主线程的EventLoop对象 -- 负责监听事件(读事件)的处理
    Acceptor _acceptor;      // 监听套接字的管理对象
    LooPThreadPool  _pool;   // 从属线程池
    std::unordered_map<uint64_t, PtrConnection> _conns;  // 保存管理所有连接对应的shared_ptr对象

    using ConectedCallback = std::function<void(const PtrConnection&)>;
    using MessageCallback = std::function<void(const PtrConnection&, Buffer*)>;
    using CloseCallback = std::function<void(const PtrConnection&)>;
    using AnyEventCallback = std::function<void(const PtrConnection&)>;
    ConectedCallback _connected_callback;
    MessageCallback _message_callback;
    CloseCallback _close_callback;
    AnyEventCallback _anyevent_callback;

    using Functor = std::function<void()>;

private:
    // 为新的连接创建一个Connetion进行管理
    void NewConnection(int fd)
    {
        _next_index++;
        
        PtrConnection connection (new Connection(_pool.NextLoop(), _next_index, fd));
        // 设置各种回调函数
        connection->SetMessageCallback(_message_callback); 
        connection->SetCloseCallback(_close_callback); 
        connection->SetConectedCallback(_connected_callback);
        connection->SetAnyEventCallback(_anyevent_callback);
        connection->SetServerCloseCallback(std::bind(&TcpServer::RemoveConnection, this, std::placeholders::_1));

         // 启动非活跃超时销毁
        if(_enable_inactive_release)
            connection->EnableInactiveRelease(_timerout);

        // 就绪初始化
        connection->Established(); 
        
        _conns.insert(std::make_pair(_next_index, connection));
    }

    void RemoveConnectionInLoop(const PtrConnection& connection)
    {
        int id = connection->ConnectId();
        auto iter = _conns.find(id);
        if(iter != _conns.end())
        {
            _conns.erase(id);
        }
        return;
    }

    // 从管理Connetion的_conns中移除连接信息
    void RemoveConnection(const PtrConnection& connection)
    {
        // 保证线程安全, 必须要在一个线程中执行
        _base_loop.RunInLoop(std::bind(&TcpServer::RemoveConnectionInLoop, this, connection));
    }

    // 添加一个定时任务
    void RunAfterInLoop(const Functor& task, int delay)
    {
        _next_index++;
        _base_loop.TimerAdd(_next_index, delay, task);
    }

public:
    TcpServer(int port)
        :_port(port), _next_index(0), _enable_inactive_release(false)
        ,_acceptor(&_base_loop, port), _pool(&_base_loop)
    {
        // 为新的连接创建一个Connetion进行管理
        _acceptor.SetAcceptCallback(std::bind(&TcpServer::NewConnection, this, std::placeholders::_1));
        // 并将监听套接字挂到baseloop上
        _acceptor.Listen(); 
    }

    void SetThreadCount(int count)
    {
        return _pool.SetThreadCount(count);
    }

    void SetConectedCallback(const ConectedCallback& cb)
    {
        _connected_callback = cb;
    }

    void SetMessageCallback(const MessageCallback& cb)
    {
        _message_callback = cb;
    }

    void SetCloseCallback(const CloseCallback& cb)
    {
        _close_callback = cb;
    }

    void SetAnyEventCallback(const AnyEventCallback& cb)
    {
        _anyevent_callback = cb;
    }

    void EnableInactiveRelease(int timerout)
    {
        _timerout = timerout;
        _enable_inactive_release = true;
    }

    // 添加一个定时任务
    void RunAfter(const Functor& task, int delay)
    {
        _base_loop.RunInLoop(std::bind(&TcpServer::RunAfterInLoop, this, task, delay));
    }

    void Start()
    {
        // 创建线程池中的从属线程 -- 启动之前创建, 不能在构造函数时创建
        _pool.Create();
        // 开始监控
        return _base_loop.Start();
    }

};

// 移除监控
void Channel::Remove()
{
    // 后边会调用EventLoop接口来移除监控
    return _loop->RemoveEvent(this);
}

void Channel::Update() 
{
   return _loop->UpdateEvent(this); 
}

void TimerWheel::TimerAdd(uint64_t id, uint32_t delay, const TaskFunc& cb)
{
    return _loop->RunInLoop(std::bind(&TimerWheel::TimerAddInLoop, this, id, delay, cb));
}

void TimerWheel::TimerRefresh(u_int64_t id)
{
    
    return _loop->RunInLoop(std::bind(&TimerWheel::TimerRefreshInLoop, this, id));
}

void TimerWheel::TimerCancel(uint64_t id)
{
    return _loop->RunInLoop(std::bind(&TimerWheel::TimerCancelInLoop, this, id));
}

// 对连接关闭触发SIGPIPE信号进行自定义捕捉
class NetWort
{
public:
    NetWort()
    {
        DBG_LOG("SIGPIPE INT!");
        signal(SIGPIPE, SIG_IGN);
    }
};
static NetWort nt;